System and method for near-synchronous replication for object store

ABSTRACT

An illustrative embodiment disclosed herein is an apparatus including a processor having programmed instructions to detect an operation associated with a first object instance in a first cluster, determine that the first object instance is configured for replication to a second cluster, create an object information (info) metadata entry for the first object instance, create an object replication metadata entry for the first object instance, and simultaneously write the object info metadata entry and the object replication metadata entry to a first data structure and a second data structure, respectively.

CROSS-REFERENCE TO RELATED APPLICATION

This application is related and claims priority under 35 U.S. § 119(e) to U.S. Provisional Patent Application No. 63/039,935, filed Jun. 16, 2020, titled “SYSTEM AND METHOD FOR NEAR-SYNCHRONOUS REPLICATION FOR OBJECT STORE,” and the U.S. Provisional Patent Application No. 63/032,122, filed May 29, 2020, titled “SYSTEM AND METHOD FOR MULTI-CLUSTER STORAGE,” the entire contents of which are incorporated herein by reference for all purposes.

BACKGROUND

The following description is provided to assist the understanding of the reader. None of the information provided or references cited is admitted to be prior art.

Virtual computing systems are widely used in a variety of applications. Virtual computing systems include one or more host machines running one or more virtual machines concurrently. The virtual machines utilize the hardware resources of the underlying host machines. Each virtual machine may be configured to run an instance of an operating system. Modern virtual computing systems allow several operating systems and several software applications to be safely run at the same time on the virtual machines of a single host machine, thereby increasing resource utilization and performance efficiency. However, the present-day virtual computing systems have limitations due to their configuration and the way they operate.

SUMMARY

Aspects of the present disclosure relate generally to a virtualization environment, and more particularly to a system and method for near-synchronous replication for object store.

An illustrative embodiment disclosed herein is an apparatus including a processor having programmed instructions to detect an operation associated with a first object instance in a first cluster, determine that the first object instance is configured for replication to a second cluster, create an object information (info) metadata entry for the first object instance, create an object replication metadata entry for the first object instance, and simultaneously write the object info metadata entry and the object replication metadata entry to a first data structure and a second data structure, respectively.

Another illustrative embodiment disclosed herein is an apparatus including a non-transitory computer readable storage medium including instructions stored thereon, when executed by a processor, cause the processor to detect an operation associated with a first object instance in a first cluster, determine that the first object instance is configured for replication to a second cluster, create an object information (info) metadata entry for the first object instance, create an object replication metadata entry for the first object instance, and simultaneously write the object info metadata entry and the object replication metadata entry to a first data structure and a second data structure, respectively.

Another illustrative embodiment disclosed herein is an apparatus including a computer-implemented method including detecting, by a processor, an operation associated with a first object instance in a first cluster, determining, by the processor, that the first object instance is configured for replication to a second cluster, creating, by the processor, an object information (info) metadata entry for the first object instance, creating, by the processor, an object replication metadata entry for the first object instance, and simultaneously writing, by the processor, the object info metadata entry and the object replication metadata entry to a first data structure and a second data structure, respectively.

Further details of aspects, objects, and advantages of the disclosure are described below in the detailed description, drawings, and claims. Both the foregoing general description and the following detailed description are exemplary and explanatory, and are not intended to be limiting as to the scope of the disclosure. Particular embodiments may include all, some, or none of the components, elements, features, functions, operations, or steps of the embodiments disclosed above. The subject matter which can be claimed comprises not only the combinations of features as set out in the attached claims but also any other combination of features in the claims, wherein each feature mentioned in the claims can be combined with any other feature or combination of other features in the claims. Furthermore, any of the embodiments and features described or depicted herein can be claimed in a separate claim and/or in any combination with any embodiment or feature described or depicted herein or with any of the features of the attached claims.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is an example block diagram of a virtual computing system, in accordance with some embodiments of the present disclosure.

FIG. 2 is an example block diagram of an object store cluster, in accordance with some embodiments of the present disclosure.

FIG. 3 is an example block diagram of an object store cluster, in accordance with some embodiments of the present disclosure.

FIG. 4 is a flowchart of an example method for tracking changes, in accordance with some embodiments of the present disclosure.

FIG. 5 is an example block diagram of multiple object store clusters instances, in accordance with some embodiments of the present disclosure.

FIG. 6 is an example block diagram of multiple object store clusters, in accordance with some embodiments of the present disclosure.

FIG. 7 is a flowchart of an example method for transferring data, in accordance with some embodiments of the present disclosure.

FIG. 8 is an example block diagram of multiple object store clusters, in accordance with some embodiments of the present disclosure.

FIG. 9 is a flowchart of an example method for failover and failback, in accordance with some embodiments of the present disclosure.

FIG. 10 illustrates a block diagram of a computing system suitable for implementing particular embodiments disclosed herein.

The foregoing and other features of the present disclosure will become apparent from the following description and appended claims, taken in conjunction with the accompanying drawings. Understanding that these drawings depict only several embodiments in accordance with the disclosure and are, therefore, not to be considered limiting of its scope, the disclosure will be described with additional specificity and detail through use of the accompanying drawings.

DETAILED DESCRIPTION

In the following detailed description, reference is made to the accompanying drawings, which form a part hereof. In the drawings, similar symbols typically identify similar components, unless context dictates otherwise. The illustrative embodiments described in the detailed description, drawings, and claims are not meant to be limiting. Other embodiments may be utilized, and other changes may be made, without departing from the spirit or scope of the subject matter presented here. It will be readily understood that the aspects of the present disclosure, as generally described herein, and illustrated in the figures, can be arranged, substituted, combined, and designed in a wide variety of different configurations, all of which are explicitly contemplated and make part of this disclosure.

Data replication improves data availability and accessibility, as well as system resilience and reliability. One common use of data replication is for disaster recovery, to ensure that an accurate backup exists in case of a hardware failure or data breach. However, conventional systems do not provide data protection for object stores across geographic regions. So, for example, if a datacenter goes down, all of the data on the object stores can be lost unless the data was replicated to a datacenter in another region. What is needed is cross-region replication services for object stores.

Synchronous replication ensures all data written in the source storage is simultaneously written in the target storage, and waits for acknowledgement from both storage arrays before completing the operation. Synchronous replication has a large performance overhead of the link between storage arrays and relies on matching storage between source and target with fibre channel latencies to minimize this overhead. Asynchronous replication uses snapshots to take a point in time copy of the data that has changed and sends it to the recovery site on a schedule. The frequency is typically set on a schedule of hours, depending on the number and frequency of snapshots that the storage and application can withstand. Because of the schedule, asynchronous replication has a greater latency than other replication models. Conventional near-synchronous models are problematic because of the storage and latency overhead for tracking changes in the replicated instances. What is needed is a replication service that provides that provides the benefits of synchronous replication and asynchronous replication for object stores, while minimizing the overhead of conventional near-synchronous approaches.

Disclosed herein is a system and method to replicate object storage data and entities across geographic regions in a near-synchronous (sync) approach that uses separate database maps for the object information and the object replication information. Near sync replication for object storage addresses the need for replicating data to maintain multiple copies across failure domains for various reasons including disaster recovery, compliance, availability, etc. The present disclosure provides a method to track changes on the object storage system and replicate the object storage system to other object storage systems including in other geographic regions. Benefits of using separate database maps include reducing storage overhead by only replicating the object information and claiming back storage space by deleting the object replication information after replication is complete. Tracking both database maps can be done using atomic writes to reduce latency. Advantageously, the cross-region functionality ensures greater data protection. Other benefits include a lower latency in replicating than the asynchronous model without the reliance on performance overhead and/or fibre optic cables as in the synchronous model.

Object Virtualization Technology and Environment

Referring now to FIG. 1, a virtual computing system 100 is shown, in accordance with some embodiments of the present disclosure. The virtual computing system 100 includes a plurality of nodes, such as a first node 105A, a second node 105B, and a third node 105C. The nodes may be collectively referred to herein as “nodes 105.” Each of the nodes 105 may also be referred to as a “host” or “host machine.” The first node 105A includes an object virtual machine (“OVMs”) 111A and 111B (collectively referred to herein as “OVMs 111”), a controller virtual machine (“CVM”) 115A, and a hypervisor 125A. Similarly, the second node 105B includes OVMs 112A and 112B (collectively referred to herein as “OVMs 112”), a CVM 115B, and a hypervisor 125B, and the third node 105C includes OVMs 113A and 113B (collectively referred to herein as “OVMs 113”), a CVM 115C, and a hypervisor 125C. The OVMs 111, 112, and 113 may be collectively referred to herein as “OVMs 110.” The CVMs 115A, 115B, and 115C may be collectively referred to herein as “CVMs 115.” The nodes 105 are connected to a network 165.

The virtual computing system 100 also includes a storage pool 140. The storage pool 140 may include network-attached storage (NAS) 150 and direct-attached storage (DAS) 145A, 145B, and 145C (collectively referred to herein as DAS 145). The NAS 150 is accessible via the network 165 and, in some embodiments, may include cloud storage 155, as well as local area network (“LAN”) storage 160. In contrast to the NAS 150, which is accessible via the network 165, each of the DAS 145A, the DAS 145B, and the DAS 145C includes storage components that are provided internally within the first node 105A, the second node 105B, and the third node 105C, respectively, such that each of the first, second, and third nodes may access its respective DAS without having to access the network 165.

The CVM 115A may include one or more virtual disks (“vdisks”) 120A, the CVM 115B may include one or more vdisks 120B, and the CVM 115C may include one or more vdisks 120C. The vdisks 120A, the vdisks 120B, and the vdisks 120C are collectively referred to herein as “vdisks 120.” The vdisks 120 may be a logical representation of storage space allocated from the storage pool 140. Each of the vdisks 120 may be located in a memory of a respective one of the CVMs 115. The memory of each of the CVMs 115 may be a virtualized instance of underlying hardware, such as the RAMs 135 and/or the storage pool 140. The virtualization of the underlying hardware is described below.

In some embodiments, the CVMs 115 may be configured to run a distributed operating system in that each of the CVMs 115 run a subset of the distributed operating system. In some embodiments, the CVMs 115, and the underlying storage of the nodes (e.g., nodes 105) exposed by the CVMs 115, form one or more storage clusters (e.g., Nutanix Operating System (“NOS”) clusters, physical clusters, storage layer). In some embodiments, the NOS cluster is distributed across multiple nodes. For example, the CVMs 115A-C may be a NOS cluster. In some embodiments, the one or more NOS clusters include greater than or fewer than the CVMs 115. In some embodiments, each of the CVMs 115 run a separate, independent instance of an operating system.

In some embodiments, the OVMs 110 form an OVM cluster (e.g., object store cluster, object store system, object storage service, client layer, object layer). OVMs of an OVM cluster may be configured to share resources with each other. The OVMs in the OVM cluster may be configured to access storage from the NOS cluster (e.g., using one or more of the vdisks 120 as a storage unit). In some embodiments, the OVM cluster is distributed across multiple nodes. For example, the OVMs 111A, 112A, and 113A may be an OVM cluster.

Some or all of the OVMs 110 in the OVM cluster may be configured to run software-defined object storage service, such as Nutanix Buckets™ or Nutanix Objects™. As part of the object storage service (OSS), the OVMs 110 may be configured to deploy (e.g., create) a collection of buckets. A bucket is a virtual representation of, and is created on (e.g., on top of), a virtual disk (e.g., the virtual disk 120A in FIG. 1), or other data store. A bucket is like a folder except that a bucket has a hierarchy flat, whereas a folder has recursion (e.g., sub-folders). The OVMs 110 store/add one or more objects in/to one or more of the buckets (by storing the one or more objects in one or more virtual disks 120 backing the one or more buckets), and manage the buckets and objects. An object can be anything: a file, a document, a spreadsheet, a video, a data, metadata, etc. When buckets are created, they are assigned (e.g., given) endpoints through which the OVMs 110, external users or applications interfacing with the OVMs 110, can access them. Examples of endpoints are uniform resource locators (URLs). After a bucket is created, objects can be added.

Regions from vdisks are allocated to buckets. A region provides the high-level mapping between at least one of an object or a bucket and the corresponding locations on a vdisk (e.g., a vDisk ID, vdisk offset, and vdisk length). Vdisks may be subdivided (e.g. chunked) into multiple fixed-size regions. A region can include portions (e.g., chunks, stripes, blocks, locations) of multiple vdisks.

Multiple OVM clusters and/or multiple NOS clusters may exist within a given virtual computing system (e.g., the virtual computing system 100). A central management system, such as Prism Central, may manage a configuration of the multiple OVM clusters and/or multiple NOS clusters. The configuration may include a list of OVM clusters, a mapping of each OVM cluster to a list of NOS clusters from which the OVM cluster may access storage, and/or a mapping of each OVM cluster to a list of vdisks that the OVM cluster owns or has access to.

Each of the OVMs 110 and the CVMs 115 is a software-based implementation of a computing machine in the virtual computing system 100. The OVMs 110 and the CVMs 115 emulate the functionality of a physical computer. Specifically, the hardware resources, such as CPU, memory, storage, etc., of a single physical server computer (e.g., the first node 105A, the second node 105B, or the third node 105C) are virtualized or transformed by the respective hypervisor (e.g. the hypervisor 125A, the hypervisor 125B, and the hypervisor 125C), into the underlying support for each of the OVMs 110 and the CVMs 115 that may run its own operating system, a distributed operating system, and/or applications on the underlying physical resources just like a real computer. By encapsulating an entire machine, including CPU, memory, operating system, storage devices, and network devices, the OVMs 110 and the CVMs 115 are compatible with most standard operating systems (e.g. Windows, Linux, etc.), applications, and device drivers. Thus, each of the hypervisors 125 is a virtual machine monitor that allows the single physical server computer to run multiple instances of the OVMs 110 (e.g. the OVM 111) and at least one instance of a CVM 115 (e.g. the CVM 115A), with each of the OVM instances and the CVM instance sharing the resources of that one physical server computer, potentially across multiple environments. By running the multiple instances of the OVMs 110 on a node of the nodes 105, multiple workloads and multiple operating systems may be run on the single piece of underlying hardware computer to increase resource utilization and manage workflow.

The hypervisors 125 of the respective nodes 105 may be configured to run virtualization software, such as, ESXi from VMWare, AHV from Nutanix, Inc., XenServer from Citrix Systems, Inc., etc. The virtualization software on the hypervisors 125 may be configured for managing the interactions between the respective OVMs 110 (and/or the CVMs 115) and the underlying hardware of the respective nodes 105. Each of the CVMs 115 and the hypervisors 125 may be configured as suitable for use within the virtual computing system 100.

In some embodiments, each of the nodes 105 may be a hardware device, such as a server. For example, in some embodiments, one or more of the nodes 105 may be an NX-1000 server, NX-3000 server, NX-5000 server, NX-6000 server, NX-8000 server, etc. provided by Nutanix, Inc. or server computers from Dell, Inc., Lenovo Group Ltd. or Lenovo PC International, Cisco Systems, Inc., etc. In other embodiments, one or more of the nodes 105 may be another type of hardware device, such as a personal computer, an input/output or peripheral unit such as a printer, or any type of device that is suitable for use as a node within the virtual computing system 100. In some embodiments, the virtual computing system 100 may be part of a data center.

The first node 105A may include one or more central processing units (“CPUs”) 130A, the second node 105B may include one or more CPUs 130B, and the third node 105C may include one or more CPUs 130C. The CPUs 130A, 130B, and 130C are collectively referred to herein as the CPUs 130. The CPUs 130 may be configured to execute instructions. The instructions may be carried out by a special purpose computer, logic circuits, or hardware circuits of the first node 105A, the second node 105B, and the third node 105C. The CPUs 130 may be implemented in hardware, firmware, software, or any combination thereof. The term “execution” is, for example, the process of running an application or the carrying out of the operation called for by an instruction. The instructions may be written using one or more programming language, scripting language, assembly language, etc. The CPUs 130, thus, execute an instruction, meaning that they perform the operations called for by that instruction.

The first node 105A may include one or more random access memory units (“RAM”) 135A, the second node 105B may include one or more RAM 135B, and the third node 105C may include one or more RAM 135C. The RAMs 135A, 135B, and 135C are collectively referred to herein as the RAMs 135. The CPUs 130 may be operably coupled to the respective one of the RAMs 135, the storage pool 140, as well as with other elements of the respective ones of the nodes 105 to receive, send, and process information, and to control the operations of the respective underlying node. Each of the CPUs 130 may retrieve a set of instructions from the storage pool 140, such as, from a permanent memory device like a read only memory (“ROM”) device and copy the instructions in an executable form to a temporary memory device that is generally some form of random access memory (“RAM”), such as a respective one of the RAMs 135. One of or both of the ROM and RAM be part of the storage pool 140, or in some embodiments, may be separately provisioned from the storage pool. The RAM may be stand-alone hardware such as RAM chips or modules. Further, each of the CPUs 130 may include a single stand-alone CPU, or a plurality of CPUs that use the same or different processing technology.

Each of the DAS 145 may include a variety of types of memory devices. For example, in some embodiments, one or more of the DAS 145 may include, but is not limited to, any type of RAM, ROM, flash memory, magnetic storage devices (e.g., hard disk, floppy disk, magnetic strips, etc.), optical disks (e.g., compact disk (“CD”), digital versatile disk (“DVD”), etc.), smart cards, solid state devices, etc. Likewise, the NAS 150 may include any of a variety of network accessible storage (e.g., the cloud storage 155, the LAN storage 160, etc.) that is suitable for use within the virtual computing system 100 and accessible via the network 165. The storage pool 140, including the NAS 150 and the DAS 145, together form a distributed storage system configured to be accessed by each of the nodes 105 via the network 165, one or more of the OVMs 110, one or more of the CVMs 115, and/or one or more of the hypervisors 125.

Each of the nodes 105 may be configured to communicate and share resources with each other via the network 165, including the respective one of the CPUs 130, the respective one of the RAMs 135, and the respective one of the DAS 145. For example, in some embodiments, the nodes 105 may communicate and share resources with each other via one or more of the OVMs 110, one or more of the CVMs 115, and/or one or more of the hypervisors 125. One or more of the nodes 105 may be organized in a variety of network topologies.

The network 165 may include any of a variety of wired or wireless network channels that may be suitable for use within the virtual computing system 100. For example, in some embodiments, the network 165 may include wired connections, such as an Ethernet connection, one or more twisted pair wires, coaxial cables, fiber optic cables, etc. In other embodiments, the network 165 may include wireless connections, such as microwaves, infrared waves, radio waves, spread spectrum technologies, satellites, etc. The network 165 may also be configured to communicate with another device using cellular networks, local area networks, wide area networks, the Internet, etc. In some embodiments, the network 165 may include a combination of wired and wireless communications.

Although three of the plurality of nodes (e.g., the first node 105A, the second node 105B, and the third node 105C) are shown in the virtual computing system 100, in other embodiments, greater than or fewer than three nodes may be used. Likewise, although only two of the OVMs are shown on each of the first node 105A (e.g. the OVMs 111), the second node 105B, and the third node 105C, in other embodiments, greater than or fewer than two OVMs may reside on some or all of the nodes 105.

It is to be understood again that only certain components and features of the virtual computing system 100 are shown and described herein. Nevertheless, other components and features that may be needed or desired to perform the functions described herein are contemplated and considered within the scope of the present disclosure. It is also to be understood that the configuration of the various components of the virtual computing system 100 described above is only an example and is not intended to be limiting in any way. Rather, the configuration of those components may vary to perform the functions described herein.

Near-Synchronous Replication of Object Store

In some embodiments, e.g., in a forward path, object operations (e.g., put, update, delete) do (e.g., cause, trigger, etc.) an metadata update to an object replication map (e.g., a key-value pair and/or a column family in a database such as a log structured merge database) to record an entry for replication. In some embodiments, the update is an atomic update along with object info. In some embodiments, the atomicity is guaranteed by keeping a key same for both object info and object replication map entries and updating them together as an atomic write to a metadata storage structure (e.g., a database, a log structured merge database). This map may absorb (e.g., include, store, record, track, combine, etc.) all the pending object replications. In some embodiments, the map has an entry for each object version.

In some embodiments, the object replication map entry tracks a put-id for each object put. In some embodiments, object overwrites and updates replace the put-id, such that the id always corresponds to the latest modification of the object. In some embodiments, the put-id is a global id across all objects assigned from zookeeper. In some embodiments, the map entry is alive (e.g., accessible, readable, not deleted) as long as replication is pending on the object and is purged (e.g., deleted) when the replication of latest version is complete.

Referring now to FIG. 2, an example block diagram of an object store cluster 200 is shown, in accordance with some embodiments of the present disclosure. The object store cluster 200 (e.g., object store instance 200, object store service 200) includes an object controller 201, a metadata service 202 coupled to the object controller 201, and a storage structure 203 coupled to the metadata service 202.

The object store cluster 200 may capture changes in one or more metadata maps. Object and bucket mutations create an entry in the one or more metadata maps. Overwrites may be absorbed in place.

In some embodiments, the storage structure 203 stores the map for storing object mutations (e.g., changes, delta) that may be replicated from a first object store service to a second object store cluster. In some embodiments, the metadata service 202 creates (e.g., generates, identifies) a map entry for each object that may be replicated. In some embodiments, the object controller 201 updates (e.g., sends a request to the metadata service 202) object information (info) for an object that is replicated to another cluster. In some embodiments, the metadata service 202 or the object controller 201 tracks an identifier (put -id) for each object mutation. The put-id may correspond to the latest mutation of the object.

In some embodiments, the metadata service 202 updates/replaces metadata associated with the object info and object replication info, including the put-id. In some embodiments, the object overwrites, and the put-id is updated/replaced (read modify write). The put-id may be global id across all objects (e.g., of a bucket, a cluster, multiple clusters). The object replication info may be updated along with object info. In some embodiments, a same key is used for both object info and object replication map entries. In some embodiments, the metadata write (e.g., atomic write) to the storage structure 203. In some embodiments, each of the object info and object replication info are stored as a key-value. For example, the key is the object info map key and the value is at least one of the put id, an upload id, a time to delete, a time when created, or a transfer state of at least one of the put id or the upload id.

In some embodiments, the object store cluster 200 may perform concurrent puts. Referring now to FIG. 3, an example block diagram of the object store cluster 200 is shown, in accordance with some embodiments of the present disclosure. A concurrent put is a put operation by multiple object controllers like object controller 201. When performing concurrent puts, the put id for the entry may be different than the put id for each object instance associated with each object controller.

Bucket operations would follow the same approach as object operations workflow, just that the entries are maintained in a separate map bucket replication map.

In some embodiments, the storage structure 203 stores a map for storing bucket mutations (e.g., changes) that may be replicated from a first object store cluster to a second object store cluster. In some embodiments, the metadata service 202 creates (e.g., generates, identifies, stores in memory) a map entry for each bucket that may be replicated. In some embodiments, the bucket controller 201 updates (e.g., sends a request to the metadata service 202) bucket information (info) for an bucket that is replicated to another cluster. In some embodiments, the metadata service 202 or the bucket controller 201 tracks an identifier (put -id) for each bucket mutation. The put-id may correspond to the latest mutation of the bucket.

In some embodiments, the metadata service 202 updates/replaces metadata associated with the bucket info and bucket replication info, including the put-id. In some embodiments, the bucket overwrites, and the put-id is updated/replaced (read modify write). The put-id may be global id across all buckets (e.g., of a bucket, a cluster, multiple clusters). The bucket replication info may be updated along with bucket info. In some embodiments, a same key is used for both bucket info and bucket replication map entries. In some embodiments, the metadata write (e.g., atomic write) to the storage structure 203. In some embodiments, each of the bucket info and bucket replication info are stored as a key-value.

The storage structure 203 may include a log-structured merge-trees (LSM tree) tree based key-value (KV) store. The LSM tree based KV store includes a Commitlog, a MemTable, and SSTables. The Commitlog and sorted string tables (SSTables) are on-disk while the MemTable is an in-memory data structure. The Commitlog is an append-only file which is used as a log for recovery purposes. The MemTable is used to absorb writes and speed up the write path. The SSTables are sorted, immutable files which store all the key-value pairs persistently. The SSTables are sometimes divided into multiple levels, with each level having larger SSTables than the one before it.

An LSM tree's write/update to a key is treated as a new write and does not update the previous value for the key. This gives the advantage of writes being fast as it does not search for the previously written value and then update it.

The write path involves appending the Commitlog file with the key-value pair (e.g., database map, metadata entry of database map) and then updating the MemTable. All writes have to be sequentially written to the Commitlog and if writes come in parallel, they will be serialized while writing to it. Once the MemTable or the Commitlog crosses a predefined limit, the MemTable content is written into the disk (flushing) to create an SSTable. The SSTable contains the key-value pairs sorted based on the key. However, since updates to keys are treated as new writes, the multiple SSTables may include duplicate entries for the key, where the newest SSTable always has the right value for the key. To clean up the older entries, LSM trees perform compaction.

An LSM's read is more involved process, in some embodiments. It can require searching for the value of the key in the MemTable and multiple SSTable files. This is the consequence of updates being treated as new writes and leaving existing values to be cleaned up by compaction. Hence, the LSM does all the querying in parallel to avoid wasting time on the MemTable or a single SSTable.

Some embodiments for the read path include consulting the most recent SSTables first since the newest entry is always the right one and using bloom filters to filter out SSTables. Bloom filters provide the guarantee that if the bloom filter returns false, then the key definitely does not exist in the SSTable, but if the bloom filter returns true, then the key might still not exist in the SSTable.

The efficiency of the read path heavily depends on the number of SSTable files in the LSM since at least one disk I/O (e.g., read or write) may be performed per SSTable file. The size amplification of the LSM tree directly impacts the read performance of the LSM tree.

Scan operations on the LSM involves finding all valid key-value pairs in the database, usually between a user-defined range. A valid key-value pair is one which has not been deleted. While each SSTable file and the MemTables are sorted structures, they can have overlapping ranges causing, in some embodiments, an un-sorted view of the entire database.

The LSM iterator may generate a sorted view for the client. In some embodiments, it iterates through the keys for every SSTable and is also responsible for discarding the obsolete key-value pairs returned from older SSTables which have not been compacted yet.

Scans are generally more challenging to solve in an LSM based key-value store than a B-tree based store due to the presence of obsolete key-value pairs in older SSTables that need to be skipped. Scan performance is also directly tied to the number of SSTable files and the amount of obsolete key-value pairs present in the database. Reading obsolete key-value pairs has an impact to performance by using additional CPU, memory, and I/O bandwidth.

Compaction is the key process that is responsible for cleaning up obsolete key-value pairs and reducing the number of SSTables in the database. Compaction includes, in some embodiments, selecting the SSTable files to perform compaction for (e.g., there are various heuristics that different implementations consider), reading all the key-value pairs from the SSTables into memory, merging the key-value pairs to form a single sorted stream (including removing the obsolete key-value pairs due to updates or deletes), writing the single sorted stream as a new SSTable file, and deleting the old/obsolete SSTable files.

In some embodiments, compaction is a CPU/memory intensive process since it maintains a large number of keys and has to perform merge-sort across multiple incoming sorted streams. In some embodiments, compaction is I/O intensive since it can generate read and write working sets which encompass the entire database and in-turn impact user-facing read/write/scan operations.

Referring now to FIG. 4, a flowchart of an example method 400 for tracking change is illustrated. The method 400 may be implemented using, or performed by, an object store cluster 200, one or more components/elements/entities of the object store cluster 200, a processor associated with the object store cluster 200, or one or more processors respectively associated one or more components/elements/entities of the object store cluster 200, which is detailed herein with respect to the virtual computing system 100 of FIG. 1 and the object store cluster 200 of FIG. 2. Additional, fewer, or different operations may be performed in the method 400 depending on the embodiment.

A first cluster (e.g., the object store cluster 200) detects an operation (e.g., a request, an operation request, an API call, a put operation, a get operation, etc.) associated with the first object instance in the first cluster (402). In some embodiments, the first cluster is in a first geographic region (e.g., first availability zone). The operation may be from a client (e.g., a user, an API user, another application). The first cluster determines that the first object instance is configured for replication to a second cluster (404). In some embodiments, the second cluster is in a second geographic region (e.g., second availability zone) different from the first geographic region. In some embodiments, the first cluster determines that the first object instance is configured for replication by identifying (e.g., extracting, reading, determining) the object replication configuration from a policy (e.g., object policy, user policy, geographic region policy, etc.)

If not already created, the first cluster creates an object information (info) metadata entry for a first object instance in the first cluster replicated to a second object instance in a second cluster (406). If not already created, and, in some embodiments, responsive to determining that the first object instance is configured for replication, the first cluster creates an object replication metadata entry for the first object instance (408). In some embodiments, the metadata entries are created in-memory (e.g., in volatile memory, in a cache associated with a processor, in a MemTable associated with an LSM database). In some embodiments, a first portion of at least one of data or metadata associated with the operation is written to the object info metadata entry, and a second portion of the at least one of data or metadata associated with the operation is written to the object replication metadata entry (e.g., in-memory).

The object store cluster (e.g., simultaneously, at a same time) writes (e.g., updates, atomic writes) the object info metadata entry and the object replication metadata entry to a first data structure and a second data structure, respectively (410). In some embodiments, the first and second data structures are separate database maps (e.g., key-value pairs, columns, column families in an LSM database). In some embodiments, (e.g., only) the object info metadata entry is replicated to a secondary cluster. In some embodiments, a duration (e.g., lifetime, time to expiry, etc.) of the object info metadata entry is greater than a predetermined or dynamic threshold (e.g., more permanent) and a duration of object replication metadata entry is less than the predetermined or dynamic threshold (e.g., more temporary). In some embodiments, after replication is completed (see FIG. 7 below), the object replication metadata entry is deleted. Advantageously, having the separate database maps reduces overhead (e.g., memory overhead) by at least one of deleting, reducing the duration of, or not replicating the object replication metadata entry.

In some embodiments, the first cluster sends, to the client, a response to the operation associated with the first object instance in the first cluster. In some embodiments, the response to the operation is responsive to (e.g., simultaneously) writing the object info metadata entry and the object replication metadata entry to a first data structure and a second data structure, respectively.

Data transfer may keep a single outstanding replication operation per object from source. This may prevent races from parallel transfers and thereby no need to provide protection on remote against stale updates. The object store cluster 200 may utilize multipart capability for large data transfer to the remote site. This naturally provides the ability to chunkify large objects in to parts and also to restart the transfer up on failures.

In some embodiments, an object controller (OC) such as the object controller 201 starts replication, e.g., in the forward path, if there is no previous entry for the object in a transfer map. In some embodiments, concurrent replications from other OCs back off if a previous version is found. In some embodiments, when the replication is complete for a version, and, if it is the latest version, the transfer map entry is deleted.

Replications are backed off during the forward path and failed transfers may be restarted by background scans. In some embodiments, replications started through background scan read the object metadata from a remote cluster to determine if the metadata and an etag (entity tag) matches from the source cluster before transferring the data and/or metadata. In some embodiments, the etag stored in object info is an md5sum of data. In some embodiments, the metadata of object is copied over during finalization of the transfer. In case of multipart transfer, a multipart finalization may set the metadata, and, in case of normal put, the put itself may set the metadata.

Referring now to FIG. 5, an example block diagram of multiple object store clusters 500 is shown, in accordance with some embodiments of the present disclosure. The object store clusters 500 include a source object store cluster 501 and a target object store cluster 502 in communication with the source object store cluster 501. In some embodiments, the source object store cluster 501 is in a first geographic region, and the target object store cluster 502 is in a second geographic region different from the first geographic region. Each of the object store clusters includes an object controller, a metadata service, and an I/O manager. For example, the object store cluster 501 includes an object controller 201, a metadata service 202, and an I/O manager 503, and the target object store cluster 502 includes an object controller 504, a metadata service 505, and an I/O manager 506.

In some embodiments, the object controller 201 looks up object info and object replication by using (e.g., causing, communicating with, instructing, sending a request) the metadata service 202. In some embodiments, the object controller 201 reads data by using the I/O manager 503. In some embodiments, the object controller writes at least one of an object head, an object update, or an object put by using the object controller 504 in the target object store cluster 502. In some embodiments, after the object put/update is performed, the object controller 201 determines whether an entity tag of a first object instance in the source object store cluster 501 matches an entity tag of a replicated object instance in the target object store cluster 502. If the entity tags match, the object controller 201 deletes the object replication info by using the metadata service 202.

Objects larger than a predetermined threshold may use a multipart upload whereas objects smaller than the predetermined threshold may do normal (e.g. non-multipart) put. For large transfers using multipart upload, an upload id is generated by the metadata service 202 and can be stored within the transfer map entry. In case of multipart transfer, a multipart finalization may set the metadata.

In some embodiments, for multipart objects the etag stored in object info is a combination of md5sum of individual parts. When the large object is copied over, the etag from source object may be copied to remote object instead of relying on a secondary object controller or metadata service to recompute the etag. For data integrity validation, during the transfer the large object can be chunked into different sized parts (e.g., regardless of original part sizes) and the checksum for those parts can be computed on both sites to verify the data integrity.

Referring now to FIG. 6, an example block diagram of the multiple object store clusters 500 is shown, in accordance with some embodiments of the present disclosure. The object controller 201 may perform the operations performed with respect to FIG. 5. Additionally or alternatively, the object controller may at least one of list parts, upload parts, or finalize upload, using the object controller 504.

Referring now more generally to a data transfer (e.g., with respect to FIGS. 5-6), some approaches keeps both put id and transfer state in a same object replication map entry. As a result, the object controller 201 does a lookup and update to the object replication map in the forward path during object put to determine if there is a pending replicate operation. The lookup to the object replication map to check the presence of key may be an in-memory lookup as bloom filters may be cached by the storage structure 203. In the object replication map entry, the key may be same as object info map, and the value may include at least one of a put id or a replication state of at least one of a put id, an upload id, or a LOC.

Table 1 shows an example of replication operations in the forward path:

TABLE 1 Object Controller Metadata Service Remote Site Object put data write 1. Lookup and Update object replication map with put-id x. If lookup succeeds, return replicate = false, otherwise return replicate = true 2. Assign multipart upload id for large object and store in object replication map entry and return upload id. Object put done Start replication with x Issue Object Put or Start multipart upload Object put or upload parts Send Finalize transfer (if multipart) Finalize transfer (if multipart) Object replication map entry Lookup and Delete if put-id = x

Table 2 shows an example of replication operations in the background:

TABLE 2 Object controller Metadata service Remote site Receives replication from background scan service for object Lookup object metadata (object info and user metadata) Lookup object replication map for latest put-id and multipart-upload-id Send object head Object head Compare metadata If etag matches, check and sync metadata. If etag does not match, transfer full object. For multipart uploads, compare both upload_id and etag as pair. Set Object Attributes or Object Put/Continue multipart upload

Some approaches have the object replication map track the latest put id of object and a data transfer map to track the transfer of put id. During object put, some approaches update the object replication map entry with latest put id. Serialization between replicate operations may be achieved by lookup and update of data transfer map entry which is in the background path.

Table 3 shows an example of replication and change tracking operations:

TABLE 3 Object Controller Metadata Service Remote Site Object put data write Update object info and object replication map with put-id x, return x. Object put done Start replication for put-id = x 1. Lookup data transfer map entry for object. If lookup is success, (meaning outstanding op), then abort. Otherwise update data transfer map with put-id x. 2. Allocate multipart upload-id if needed. Issue Object Put or Start multipart upload Object put or upload parts Send Finalize transfer (if multipart) Finalize transfer (if multipart) Data transfer map entry delete. Object replication map entry Lookup and Delete if put-id = x

Referring now to FIG. 7, a flowchart of an example method 700 for transferring data is illustrated. The method 700 may be implemented using, or performed by, the object store cluster 200, the source object store cluster 501, one or more components/elements/entities of the object the object store cluster 200 or the source object store cluster 501, a processor associated with the object store cluster 200 or the source object store cluster 501, or one or more processors respectively associated one or more components/elements/entities of the object store cluster 200 or the source object store cluster 501, which is detailed herein with respect to the virtual computing system 100 of FIG. 1, the object store cluster 200 of FIG. 2, and the multiple object store clusters 500 of FIG. 5. Additional, fewer, or different operations may be performed in the method 700 depending on the embodiment. In some embodiments, the method 700 is part of a bigger method including the method 400. In some embodiments, one or more operations from the method 700 are combined with (e.g., incorporate) one or more operations from the method 400.

In some embodiments, a first cluster (e.g., the source object store cluster 501, the object store cluster 200) determines that an operation requested by a client is finalized (702). In some embodiments, the first cluster is in a first geographic region. In some embodiments, the first cluster responds, to the client requesting the operation, that the operation was successful. In some embodiments, a first component of the first cluster determines that a second component of the first cluster responds, to the client requesting the operation, that the operation was successful.

The first cluster looks up object information (info) metadata entry and the object replication metadata entry associated with a first instance in the first cluster that is replicated to a replicated instance in a second cluster (e.g., the target object store cluster 502) (704). In some embodiments, the second cluster is in a second geographic region different from the first geographic region. The first cluster reads data associated with the first instance (706). The first cluster writes the data to the replicated instance (708). In some embodiments, the first cluster writes the object info to the replicated instance.

In some embodiments, the first cluster determines that an entity tag of the first instance and an entity tag of the replicated instance match (710). The first cluster deletes the object replication metadata entry (712). In some embodiments, the first cluster deletes the object replication metadata entry responsive to determining that the entity tags match.

In some embodiments, a component id space has to be synced. Object version numbers may be kept same on both sites. The component id may be incremented (e.g., bumped up) whenever the metadata service 202 on the source object store cluster 501 allocates batch of ids. Multipart objects may be replicated up on finalization of upload on the source object store cluster 501. Part objects are not replicated as they are uploaded. In some embodiments, incoming user input/output (IO) is disallowed if the cluster is in passive state, and incoming replication IO is disallowed if cluster is in active state (herein, “IO fencing”).

Customers may like to know the approximate time up to which all objects are replicated (herein, “last sync time”). The object replication map may be scanned. The lowest timestamp entry still waiting to be replicated may be identified. The create time during update of object replication map entry may be preserved. A sliding window of buckets may track a number of active replications (herein, “in memory index”). Buckets corresponds to a hourly window and number of objects waiting to be replicated.

Referring now to FIG. 8, an example block diagram of multiple OVMs 800 is shown, in accordance with some embodiments of the present disclosure. The multiple OVMs 800 include object store services OSS1-4. Each OSS is a cluster of OVMs similar to the object store clusters of FIGS. 1-3 and 5-6. The multiple OVMs 800 include a multi-cluster coordinator MCC1 in communication with the OSS1-4. Some of the OSSs include one or more buckets. For example, as shown in FIG. 8, OSS1 includes buckets B1 and B3, and OSS3 includes B2 and B4. B2 is in communication with B1 and B4 is in communication with B3.

Replication can be enabled between any buckets. Replication can be unidirectional. For example, an application (e.g., the object controller 201) replicates B1 to B2 but an application does no replicate B2 to B1. Replication can be bidirectional. For example, the replication between B3 and B4 is bidirectional. The recursion may be prevented based on the source of the IO. There may be no fencing of object IO at either region/buckets.

In some embodiments, with replication enabled, the application writes to (e.g., only) one bucket (e.g., B3 or B4 with bidirectional replication set or B1 in case of unidirectional replication) and the data gets replicated to the replica bucket. In some embodiments, the application writes to both buckets. If the application writes to both the buckets, the last write (that our OC or background does) wins regardless of their ingest time.

The buckets can be either in versioning or non-versioning state but the bucket's versioning may be the same. For example, both (B3 and B4) can be version enabled or disabled (suspended). In some embodiments, replication fails until the versioning states match.

When a site/region/instance is/becomes unavailable (e.g., failover), the application/user can write to the other site and writes may get replicated back (or not) depending on the relationship set.

Referring to FIG. 8, if a region with B1 fails, application writes to B2 (instead of B1), there is no replication to B1, so, after B1 comes back online, B1 does not have the delta. If B3 fails, the application writes to B4, and B3 comes back online, then data written to B4 gets replicated to B3. If both B3 and B4 have the updates for the same object, any version (in case of versioning enabled and collision of version id) or any of the new data (in case of versioning disabled) becomes the current. However, the integrity of such data may remain the same. For example, if object O1 with md5 M1 is on B1 replication map and O1 with md5 M2 is on B2 replication map, then either one of these can be the (e.g., actual) data, and the data has M1 or M2 (e.g., but not something else).

In some embodiments, WORM (write once, read many) policy is not enforced on replica buckets. For example, if one (B3) has WORM enabled the other (B4) may or may not have WORM enabled and it may be up to the user to maintain the policies on the buckets accordingly. Besides versioning, there is may be no other enforcement. The retention can be different, as any other metadata.

In some embodiments, there is no baseline replication. The replication may commence from the time it is enabled. In some embodiments, the user can break the replication relationship at any time and recreate relationship anytime. There is no restriction and each relationship can be similar to a new relationship.

In some embodiments, chain replication may be performed. For example B1 is replicated to B2, which is replicated to B5. In some embodiments, a single bucket can serve as the source of multiple buckets that is, B1 can be replicated to B2 and B6. A single bucket can serve as the destination of multiple buckets, that is B1 and B2 may replicate to B6.

A planned failover may include manually demoting the primary/source cluster to passive state and promote the secondary to active state. In some embodiments, in an unplanned failover (e.g., a disaster event), the primary cluster goes down and the secondary cluster is manually promoted to active state to allow user IO. In some embodiments, object and bucket replication maps grow in size as long as the replication relationship is not broken. During extended outages, if the replication relation is broken, the replication maps on secondary can be discarded.

During a failback, in some embodiments, a primary cluster transitions to become active. In some embodiments, the object replication map is discarded on the source cluster. Un-synced deletes may remain as permanent garbage. Un-synced object puts may be lost. Pending deletes may be reconciled with remote replication map to avoid garbage. In some embodiments, pending entries in object replication map are replicated from secondary to primary cluster. Primary IO on secondary cluster may be throttled. When the diff is very small, new user IO may be temporarily stopped and the re sync may be completed. In some embodiments, the secondary cluster is switched to passive state and primary cluster is switched to active.

Referring now to FIG. 9, a flowchart of an example method 900 for failover and failback is illustrated. The method 900 may be implemented using, or performed by, the object store cluster 200, the source object store cluster 501, the multi-cluster coordinator MCC1, one or more components/elements/entities of the object the object store cluster 200 of the source object store cluster 501, a processor associated with the object store cluster 200, the source object store cluster 501, or the multi-cluster coordinator MCC1, or one or more processors respectively associated one or more components/elements/entities of the object store cluster 200, the source object store cluster 501, or the multi-cluster coordinator MCC1, which is detailed herein with respect to the virtual computing system 100 of FIG. 1, the object store cluster 200 of FIG. 2, the multiple object store clusters 500 of FIG. 5, or the multiple object store clusters 800 of FIG. 8. Additional, fewer, or different operations may be performed in the method 900 depending on the embodiment. In some embodiments, the method 900 is part of a bigger method including at least one of the methods 400 and 700. In some embodiments, one or more operations from the method 900 are combined with one or more operations from at least one of the methods 400 and 700.

A multi-cluster coordinator MCC (e.g., MCC1) determines that a primary cluster (e.g., OSS1) with a first object replication map shuts down (902). In some embodiments, the primary cluster is in a first geographic region. In some embodiments, the MCC determines that multiple, or all, primary clusters in the first geographic region shut down. The multi-cluster coordinator MCC (e.g., MCC1) maintains (e.g., sets as active, gives priority to, creates, generates, loads, etc.) a second object replication map on a secondary cluster (e.g., OSS2) (904). In some embodiments, the secondary cluster is in a second geographic region different from the first geographic region. In some embodiments, maintaining the second object replication map is in response to the primary cluster shutting down.

The MCC) determines that the primary cluster restarts (906). In some embodiments, the MCC deletes, or causes the primary cluster to delete, the first object replication map on the primary cluster in response to the primary cluster restarting (908). In some embodiments, deleting the first object replication map is in response to a primary cluster restarting. In some embodiments, the MCC saves (e.g., keeps, stores, maintains, does not delete), or causes the primary cluster to save, the first object replication map. In some embodiments, the MCC uses, or causes one of the clusters to use, the first object replication map for conflict resolution.

The MCC replicates, or causes the secondary cluster to replicate, pending entries in the second object replication map from the secondary cluster to the primary cluster (910). In some embodiments, the MCC, compares, or causes one of the clusters to compare, the etags of the two clusters. The MCC deletes, or causes the secondary cluster to delete, the second object replication map on the secondary cluster (912).

In some embodiments, connections are managed directly between object store services like object controllers or metadata services. Some approaches use an envoy or other forward proxy for communication between two objects instances. The envoy may be coupled to the OSS. In some embodiments, the envoy allows to form a service mesh where services are exposed through envoy proxy. In some embodiments, the communication between objects services happen through envoy, which, in some embodiments, does transmission control protocol (TCP) forwarding.

A given customer may choose to deploy several objects instances for under a single multi-cluster domain or multiple multi-cluster domains. In some embodiments, an object store cluster deploys an identity access management (IAM) instance and all object store instances under a multi-cluster coordinator (e.g., MCC1) connect to the same master IAM. To support object store replication in a multi-MCC domain, a global IAM may be used, in which object store instances from any MCC can connect to a single master IAM service.

A global IAM can be achieved by proxy routing at the envoy where a remote IAM instance can be made available to any object store instance irrespective of which MCC it belongs. In some embodiments, the master IAM1 instance is exposed through Envoy1. In some embodiments, Envoy2 maintains a forwarding rule for IAM service as local-endpoint remote endpoint pair.

In some embodiments, the IAM database is needed on the target cluster when it becomes active. Replication of (access) keys can be done at the IAM application layer. Replication can be at the database layer (e.g., using IDF sync or postgres replication). Replication can be at the storage layer, volume group replication through AOS DR. In some embodiments, PVC is attached to existing volume groups. In some embodiments, access keys provided to users. As part of replicating data, keys can be replicated.

In some embodiments, each of the components in the object store cluster 200, the source object store cluster 501, and the target object store cluster 502, are services on one or more object virtual machines (OVMs) such as the OVMs 111A-B, 112A-B, and 113A-B of FIG. 1. In some embodiments, each OVM is dedicated to one service (e.g., the object controller 201 runs on the OVM 111A, the metadata service 202 runs on the OVM 111B, the storage structure 203 runs on the OVM 112A, and the I/O manager 503 runs on the OVM 112B. In some embodiments, one or more of the components in the object store cluster 200 are distributed across multiple OVMs (e.g., the storage structure 203 runs on the OVM 112A and the OVM 113A). In some embodiments, more greater or less than three components/services/OVMs are included in an object store cluster such as the object store cluster 200, the source object store cluster 501, and the target object store cluster 502.

Each of the elements or entities of the virtual computing system 100 and the multi-cluster storage system 200 (e.g., The object store cluster 200 the object controller 201, the metadata service 202, the storage structure 203, the I/O manager 503, the OSS1, and the MCC1), is implemented using hardware, software, or a combination of hardware or software, in one or more embodiments. The elements or entities of the virtual computing system 100 and the multi-cluster storage system 200 can include any application, program, library, script, task, service, process or any type and form of executable instructions executed by one or more processors (e.g., the CPU 130A), in one or more embodiments. Each of the one or more processors is hardware. The instructions may be stored on one or more computer readable and/or executable storage media including non-transitory storage media such as non-transitory storage media in the storage pool 140 with respect to FIG. 1.

Referring to FIG. 10, illustrated is a block diagram of an illustrative computing system 1000 suitable for implementing particular embodiments. In particular embodiments, one or more computer systems 1000 perform one or more steps of one or more methods described or illustrated herein. In particular embodiments, one or more computer systems 1000 provide functionality described or illustrated herein. In particular embodiments, software running on one or more computer systems 1000 performs one or more steps of one or more methods described or illustrated herein or provides functionality described or illustrated herein. Particular embodiments include one or more portions of one or more computer systems 1000. Herein, reference to a computer system may encompass a computing device, and vice versa. Moreover, reference to a computer system may encompass one or more computer systems.

This disclosure contemplates any suitable number of computer systems 1000. This disclosure contemplates computer system 1000 taking any suitable physical form. As example and not by way of limitation, computer system 1000 may be an embedded computer system, a system-on-chip (SOC), a single-board computer system (SBC) (such as, for example, a computer-on-module (COM) or system-on-module (SOM)), a desktop computer system, a mainframe, a mesh of computer systems, a server, a laptop or notebook computer system, a tablet computer system, or a combination of two or more of these. Computer system 1000 may include one or more computer systems 1000; be unitary or distributed; span multiple locations; span multiple machines; span multiple data centers; or reside in a cloud, which may include one or more cloud components in one or more networks. One or more computer systems 1000 may perform without substantial spatial or temporal limitation one or more steps of one or more methods described or illustrated herein. As an example and not by way of limitation, one or more computer systems 1000 may perform in real time or in batch mode one or more steps of one or more methods described or illustrated herein. One or more computer systems 1000 may perform at different times or at different locations one or more steps of one or more methods described or illustrated herein.

In some embodiments, the computer system 1000 includes a bus 1002 (e.g., an address bus and a data bus) or other communication mechanism for communicating information, which interconnects subsystems and devices, such as processor 1004, memory 1006 (e.g., RAM), static storage 1008 (e.g., ROM), dynamic storage 1010 (e.g., magnetic or optical), communication interface 1014 (e.g., modem, Ethernet card, a network interface controller (NIC) or network adapter for communicating with an Ethernet or other wire-based network, a wireless NIC (WNIC) or wireless adapter for communicating with a wireless network, such as a WI-FI network), input/output (I/O) interface 1012 (e.g., keyboard, keypad, mouse, microphone). In particular embodiments, computer system 1000 may include one or more of any such components.

In particular embodiments, processor 1004 includes hardware for executing instructions, such as those making up a computer program. Each of the components in FIGS. 1-9 (e.g., The object store cluster 200 the object controller 201, the metadata service 202, the storage structure 203, the I/O manager 503, the OSS1, and the MCC1) comprise, are coupled to, or are otherwise associated with a (shared or dedicated) processor such as the processor 1004. As an example and not by way of limitation, to execute instructions, processor 1004 may retrieve (or fetch) the instructions from an internal register, an internal cache, memory 1006, static storage 1008, or dynamic storage 1010; decode and execute them; and then write one or more results to an internal register, an internal cache, memory 1006, static storage 1008, or dynamic storage 1010. In particular embodiments, processor 1004 may include one or more internal caches for data, instructions, or addresses. This disclosure contemplates processor 1004 including any suitable number of any suitable internal caches. As an example and not by way of limitation, processor 1004 may include one or more instruction caches, one or more data caches, and one or more translation lookaside buffers (TLBs). Instructions in the instruction caches may be copies of instructions in memory 1006, static storage 1008, or dynamic storage 1010, and the instruction caches may speed up retrieval of those instructions by processor 1004. Data in the data caches may be copies of data in memory 1006, static storage 1008, or dynamic storage 1010 for instructions executing at processor 1004 to operate on; the results of previous instructions executed at processor 1004 for access by subsequent instructions executing at processor 1004 or for writing to memory 1006, static storage 1008, or dynamic storage 1010; or other suitable data. The data caches may speed up read or write operations by processor 1004. The TLBs may speed up virtual-address translation for processor 1004. In particular embodiments, processor 1004 may include one or more internal registers for data, instructions, or addresses. This disclosure contemplates processor 1004 including any suitable number of any suitable internal registers. Processor 1004 may include one or more arithmetic logic units (ALUs); be a multi-core processor; or include one or more processors 1004. Although this disclosure describes and illustrates a particular processor, this disclosure contemplates any suitable processor.

In particular embodiments, I/O interface 1012 includes hardware, software, or both, providing one or more interfaces for communication between computer system 1000 and one or more I/O devices. Computer system 1000 may include one or more of these I/O devices. One or more of these I/O devices may enable communication between a person and computer system 1000. As an example and not by way of limitation, an I/O device may include a keyboard, keypad, microphone, monitor, mouse, printer, scanner, speaker, still camera, stylus, tablet, touch screen, trackball, video camera, another suitable I/O device or a combination of two or more of these. An I/O device may include one or more sensors. This disclosure contemplates any suitable I/O devices and any suitable I/O interfaces 1012 for them. I/O interface 1012 may include one or more device or software drivers enabling processor 1004 to drive one or more of these I/O devices. I/O interface 1012 may include one or more I/O interfaces 1012. Although this disclosure describes and illustrates a particular I/O interface, this disclosure contemplates any suitable I/O interface.

In particular embodiments, communication interface 1014 includes hardware, software, or both providing one or more interfaces for communication (such as, for example, packet-based communication) between computer system 1000 and one or more other computer systems 1000 or one or more networks. As an example and not by way of limitation, communication interface 1014 may include a network interface controller (NIC) or network adapter for communicating with an Ethernet or other wire-based network or a wireless NIC (WNIC) or wireless adapter for communicating with a wireless network, such as a WI-FI network. This disclosure contemplates any suitable network and any suitable communication interface 1014 for it. As an example and not by way of limitation, computer system 1000 may communicate with an ad hoc network, a personal area network (PAN), a local area network (LAN), a wide area network (WAN), a metropolitan area network (MAN), or one or more portions of the Internet or a combination of two or more of these. One or more portions of one or more of these networks may be wired or wireless. As an example, computer system 1000 may communicate with a wireless PAN (WPAN) (such as, for example, a BLUETOOTH WPAN), a WI-FI network, a WI-MAX network, a cellular telephone network (such as, for example, a Global System for Mobile Communications (GSM) network), or other suitable wireless network or a combination of two or more of these. Computer system 1000 may include any suitable communication interface 1014 for any of these networks. Communication interface 1014 may include one or more communication interfaces 1014. Although this disclosure describes and illustrates a particular communication interface, this disclosure contemplates any suitable communication interface.

One or more memory buses (which may each include an address bus and a data bus) may couple processor 1004 to memory 1006. Bus 1002 may include one or more memory buses, as described below. In particular embodiments, one or more memory management units (MMUs) reside between processor 1004 and memory 1006 and facilitate accesses to memory 1006 requested by processor 1004. In particular embodiments, memory 1006 includes random access memory (RAM). This RAM may be volatile memory, dynamic RAM (DRAM) or static RAM (SRAM). Moreover, this RAM may be single-ported or multi-ported RAM. This disclosure contemplates any suitable RAM. Memory 1006 may include one or more memories 1006. Although this disclosure describes and illustrates particular memory, this disclosure contemplates any suitable memory.

The ROM may be mask-programmed ROM, programmable ROM (PROM), erasable PROM (EPROM), electrically erasable PROM (EEPROM), electrically alterable ROM (EAROM), or flash memory or a combination of two or more of these. In particular embodiments, dynamic storage 1010 may include a hard disk drive (HDD), a floppy disk drive, flash memory, an optical disc, a magneto-optical disc, magnetic tape, or a Universal Serial Bus (USB) drive or a combination of two or more of these. Dynamic storage 1010 may include removable or non-removable (or fixed) media. Dynamic storage 1010 may be internal or external to computer system 1000. This disclosure contemplates mass dynamic storage 1010 taking any suitable physical form. Dynamic storage 1010 may include one or more storage control units facilitating communication between processor 1004 and dynamic storage 1010.

In particular embodiments, bus 1002 includes hardware, software, or both coupling components of computer system 1000 to each other. As an example and not by way of limitation, bus 1002 may include an Accelerated Graphics Port (AGP) or other graphics bus, an Enhanced Industry Standard Architecture (EISA) bus, a front-side bus (FSB), a HYPERTRANSPORT (HT) interconnect, an Industry Standard Architecture (ISA) bus, an INFINIBAND interconnect, a low-pin-count (LPC) bus, a memory bus, a Micro Channel Architecture (MCA) bus, a Peripheral Component Interconnect (PCI) bus, a PCI-Express (PCIe) bus, a serial advanced technology attachment (SATA) bus, a Video Electronics Standards Association local (VLB) bus, or another suitable bus or a combination of two or more of these. Bus 1002 may include one or more buses. Although this disclosure describes and illustrates a particular bus, this disclosure contemplates any suitable bus or interconnects.

In some embodiments, computer system 1000 performs specific operations by processor 1004 executing one or more sequences of one or more instructions contained in memory 1006. Such instructions may be read into memory 1006 from another computer readable/usable medium, such as static storage 1008 or dynamic storage 1010. In alternative embodiments, hard-wired circuitry may be used in place of or in combination with software instructions to implement particular embodiments. Thus, particular embodiments are not limited to any specific combination of hardware circuitry and/or software. In particular embodiments, the term “logic” shall mean any combination of software or hardware that is used.

The term “computer readable medium” or “computer usable medium” as used herein refers to any medium that participates in providing instructions to processor 1004 for execution. Such a medium may take many forms, including but not limited to, nonvolatile media and volatile media. Non-volatile media includes, for example, optical or magnetic disks, such as static storage 1008 or dynamic storage 1010. Volatile media includes dynamic memory, such as memory 1006.

Common forms of computer readable media include, for example, floppy disk, flexible disk, hard disk, magnetic tape, any other magnetic medium, CD-ROM, any other optical medium, punch cards, paper tape, any other physical medium with patterns of holes, RAM, PROM, EPROM, FLASH-EPROM, any other memory chip or cartridge, or any other medium from which a computer can read.

In particular embodiments, execution of the sequences of instructions may be performed by a single computer system 1000; in alternative embodiments, two or more computer systems 1000 coupled by communication link 1016 (e.g., LAN, PTSN, or wireless network) may perform the sequence of instructions in coordination with one another.

Computer system 1000 may transmit and receive messages, data, and instructions, including program, i.e., application code, through communication link 1016 and communication interface 1014. Received program code may be executed by processor 1004 as it is received, and/or stored in static storage 1008 or dynamic storage 1010, or other non-volatile storage for later execution. A database 1020 may be used to store data accessible by the system 1000 by way of data interface 1018.

Herein, a non-transitory computer readable medium (also referred to as “computer-readable non-transitory storage medium”) includes instructions, when executed, cause a processor to execute various functionalities described herein. In some embodiments, a computer-readable non-transitory storage medium or media may be embodied as one or more semiconductor-based or other integrated circuits (ICs) (such, as for example, field-programmable gate arrays (FPGAs) or application-specific ICs (ASICs)), hard disk drives (HDDs), hybrid hard drives (HHDs), optical discs, optical disc drives (ODDS), magneto-optical discs, magneto-optical drives, floppy diskettes, floppy disk drives (FDDs), magnetic tapes, solid-state drives (SSDs), RAM-drives, SECURE DIGITAL cards or drives, any other suitable computer-readable non-transitory storage media, or any suitable combination of two or more of these. A computer-readable non-transitory storage medium may be volatile, non-volatile, or a combination of volatile and non-volatile.

It is to be understood that any examples used herein are simply for purposes of explanation and are not intended to be limiting in any way.

The herein described subject matter sometimes illustrates different components contained within, or connected with, different other components. It is to be understood that such depicted architectures are merely exemplary, and that in fact many other architectures can be implemented which achieve the same functionality. In a conceptual sense, any arrangement of components to achieve the same functionality is effectively “associated” such that the desired functionality is achieved. Hence, any two components herein combined to achieve a particular functionality can be seen as “associated with” each other such that the desired functionality is achieved, irrespective of architectures or intermedial components. Likewise, any two components so associated can also be viewed as being “operably connected,” or “operably coupled,” to each other to achieve the desired functionality, and any two components capable of being so associated can also be viewed as being “operably couplable,” to each other to achieve the desired functionality. Specific examples of operably couplable include but are not limited to physically mateable and/or physically interacting components and/or wirelessly interactable and/or wirelessly interacting components and/or logically interacting and/or logically interactable components.

With respect to the use of substantially any plural and/or singular terms herein, those having skill in the art can translate from the plural to the singular and/or from the singular to the plural as is appropriate to the context and/or application. The various singular/plural permutations may be expressly set forth herein for sake of clarity.

It will be understood by those within the art that, in general, terms used herein, and especially in the appended claims (e.g., bodies of the appended claims) are generally intended as “open” terms (e.g., the term “including” should be interpreted as “including but not limited to,” the term “having” should be interpreted as “having at least,” the term “includes” should be interpreted as “includes but is not limited to,” etc.). It will be further understood by those within the art that if a specific number of an introduced claim recitation is intended, such an intent will be explicitly recited in the claim, and in the absence of such recitation no such intent is present. For example, as an aid to understanding, the following appended claims may contain usage of the introductory phrases “at least one” and “one or more” to introduce claim recitations. However, the use of such phrases should not be construed to imply that the introduction of a claim recitation by the indefinite articles “a” or “an” limits any particular claim containing such introduced claim recitation to disclosures containing only one such recitation, even when the same claim includes the introductory phrases “one or more” or “at least one” and indefinite articles such as “a” or “an” (e.g., “a” and/or “an” should typically be interpreted to mean “at least one” or “one or more”); the same holds true for the use of definite articles used to introduce claim recitations. In addition, even if a specific number of an introduced claim recitation is explicitly recited, those skilled in the art will recognize that such recitation should typically be interpreted to mean at least the recited number (e.g., the bare recitation of “two recitations,” without other modifiers, typically means at least two recitations, or two or more recitations). Furthermore, in those instances where a convention analogous to “at least one of A, B, and C, etc.” is used, in general such a construction is intended in the sense one having skill in the art would understand the convention (e.g., “a system having at least one of A, B, and C” would include but not be limited to systems that have A alone, B alone, C alone, A and B together, A and C together, B and C together, and/or A, B, and C together, etc.). In those instances where a convention analogous to “at least one of A, B, or C, etc.” is used, in general such a construction is intended in the sense one having skill in the art would understand the convention (e.g., “a system having at least one of A, B, or C” would include but not be limited to systems that have A alone, B alone, C alone, A and B together, A and C together, B and C together, and/or A, B, and C together, etc.). It will be further understood by those within the art that virtually any disjunctive word and/or phrase presenting two or more alternative terms, whether in the description, claims, or drawings, should be understood to contemplate the possibilities of including one of the terms, either of the terms, or both terms. For example, the phrase “A or B” will be understood to include the possibilities of “A” or “B” or “A and B.” Further, unless otherwise noted, the use of the words “approximate,” “about,” “around,” “substantially,” etc., mean plus or minus ten percent.

The foregoing description of illustrative embodiments has been presented for purposes of illustration and of description. It is not intended to be exhaustive or limiting with respect to the precise form disclosed, and modifications and variations are possible in light of the above teachings or may be acquired from practice of the disclosed embodiments. It is intended that the scope of the disclosure be defined by the claims appended hereto and their equivalents. 

What is claimed:
 1. An apparatus comprising a processor having programmed instructions to: detect an operation associated with a first object instance in a first cluster; determine that the first object instance is configured for replication to a second cluster; create an object information (info) metadata entry for the first object instance; create an object replication metadata entry for the first object instance; and simultaneously write the object info metadata entry and the object replication metadata entry to a first data structure and a second data structure, respectively.
 2. The apparatus of claim 1, wherein the first cluster is in a first geographic region, and wherein the second cluster is in a second geographic region different from the first geographic region.
 3. The apparatus of claim 1, the processor having further instructions to replicate the object info metadata entry to the second cluster.
 4. The apparatus of claim 3, the processor having further instructions to delete the object replication metadata entry, responsive to replicating the object info metadata entry to the second cluster.
 5. The apparatus of claim 1, the processor having further instructions to replicate the object info metadata entry from a first bucket in the first cluster to a second bucket in the second cluster.
 6. The apparatus of claim 1, wherein a first duration of the object info metadata entry is greater than a second duration of the object replication metadata entry.
 7. The apparatus of claim 1, wherein the first data structure is associated with a first log-structured merge (LSM) database, and the second data structure is associated with a second LSM database.
 8. A non-transitory computer readable storage medium comprising instructions stored thereon, when executed by a processor, cause the processor to: detect an operation associated with a first object instance in a first cluster; determine that the first object instance is configured for replication to a second cluster; create an object information (info) metadata entry for the first object instance; create an object replication metadata entry for the first object instance; and simultaneously write the object info metadata entry and the object replication metadata entry to a first data structure and a second data structure, respectively.
 9. The medium of claim 8, wherein the first cluster is in a first geographic region, and wherein the second cluster is in a second geographic region different from the first geographic region.
 10. The medium of claim 8, further comprising instructions, when executed by the processor, cause the processor to replicate the object info metadata entry to the second cluster.
 11. The medium of claim 10, further comprising instructions, when executed by the processor, cause the processor to delete the object replication metadata entry, responsive to replicating the object info metadata entry to the second cluster.
 12. The medium of claim 8, further comprising instructions, when executed by the processor, cause the processor to replicate the object info metadata entry from a first bucket in the first cluster to a second bucket in the second cluster.
 13. The medium of claim 8, wherein a first duration of the object info metadata entry is greater than a second duration of the object replication metadata entry.
 14. The medium of claim 8, wherein the first data structure is associated with a first log-structured merge (LSM) database, and the second data structure is associated with a second LSM database.
 15. A computer-implemented method comprising: detecting, by a processor, an operation associated with a first object instance in a first cluster; determining, by the processor, that the first object instance is configured for replication to a second cluster; creating, by the processor, an object information (info) metadata entry for the first object instance; creating, by the processor, an object replication metadata entry for the first object instance; and simultaneously writing, by the processor, the object info metadata entry and the object replication metadata entry to a first data structure and a second data structure, respectively.
 16. The method of claim 15, wherein the first cluster is in a first geographic region, and wherein the second cluster is in a second geographic region different from the first geographic region.
 17. The method of claim 15, further comprising replicating the object info metadata entry to the second cluster.
 18. The method of claim 17, further comprising deleting the object replication metadata entry, responsive to replicating the object info metadata entry to the second cluster.
 19. The method of claim 15, wherein a first duration of the object info metadata entry is greater than a second duration of the object replication metadata entry.
 20. The method of claim 15, wherein the first data structure is associated with a first log-structured merge (LSM) database, and the second data structure is associated with a second LSM database. 